home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / samba.idb / usr / samba / src / source / namequery.c.z / namequery.c
Encoding:
C/C++ Source or Header  |  1998-10-28  |  15.1 KB  |  574 lines
  1. /* 
  2.    Unix SMB/Netbios implementation.
  3.    Version 1.9.
  4.    name query routines
  5.    Copyright (C) Andrew Tridgell 1994-1998
  6.    
  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 2 of the License, or
  10.    (at your option) any later version.
  11.    
  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.    
  17.    You should have received a copy of the GNU General Public License
  18.    along with this program; if not, write to the Free Software
  19.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.    
  21. */
  22.  
  23. #include "includes.h"
  24.  
  25. extern pstring scope;
  26. extern int DEBUGLEVEL;
  27.  
  28. /* nmbd.c sets this to True. */
  29. BOOL global_in_nmbd = False;
  30.  
  31. /****************************************************************************
  32. interpret a node status response
  33. ****************************************************************************/
  34. static void _interpret_node_status(char *p, char *master,char *rname)
  35. {
  36.   int numnames = CVAL(p,0);
  37.   DEBUG(1,("received %d names\n",numnames));
  38.  
  39.   if (rname) *rname = 0;
  40.   if (master) *master = 0;
  41.  
  42.   p += 1;
  43.   while (numnames--)
  44.     {
  45.       char qname[17];
  46.       int type;
  47.       fstring flags;
  48.       int i;
  49.       *flags = 0;
  50.       StrnCpy(qname,p,15);
  51.       type = CVAL(p,15);
  52.       p += 16;
  53.  
  54.       fstrcat(flags, (p[0] & 0x80) ? "<GROUP> " : "        ");
  55.       if ((p[0] & 0x60) == 0x00) fstrcat(flags,"B ");
  56.       if ((p[0] & 0x60) == 0x20) fstrcat(flags,"P ");
  57.       if ((p[0] & 0x60) == 0x40) fstrcat(flags,"M ");
  58.       if ((p[0] & 0x60) == 0x60) fstrcat(flags,"H ");
  59.       if (p[0] & 0x10) fstrcat(flags,"<DEREGISTERING> ");
  60.       if (p[0] & 0x08) fstrcat(flags,"<CONFLICT> ");
  61.       if (p[0] & 0x04) fstrcat(flags,"<ACTIVE> ");
  62.       if (p[0] & 0x02) fstrcat(flags,"<PERMANENT> ");
  63.  
  64.       if (master && !*master && type == 0x1d) {
  65.     StrnCpy(master,qname,15);
  66.     trim_string(master,NULL," ");
  67.       }
  68.  
  69.       if (rname && !*rname && type == 0x20 && !(p[0]&0x80)) {
  70.     StrnCpy(rname,qname,15);
  71.     trim_string(rname,NULL," ");
  72.       }
  73.       
  74.       for (i = strlen( qname) ; --i >= 0 ; ) {
  75.     if (!isprint(qname[i])) qname[i] = '.';
  76.       }
  77.       DEBUG(1,("\t%-15s <%02x> - %s\n",qname,type,flags));
  78.       p+=2;
  79.     }
  80.   DEBUG(1,("num_good_sends=%d num_good_receives=%d\n",
  81.            IVAL(p,20),IVAL(p,24)));
  82. }
  83.  
  84.  
  85. /****************************************************************************
  86.   do a netbios name status query on a host
  87.  
  88.   the "master" parameter is a hack used for finding workgroups.
  89.   **************************************************************************/
  90. BOOL name_status(int fd,char *name,int name_type,BOOL recurse,
  91.          struct in_addr to_ip,char *master,char *rname,
  92.          void (*fn)(struct packet_struct *))
  93. {
  94.   BOOL found=False;
  95.   int retries = 2;
  96.   int retry_time = 5000;
  97.   struct timeval tval;
  98.   struct packet_struct p;
  99.   struct packet_struct *p2;
  100.   struct nmb_packet *nmb = &p.packet.nmb;
  101.   static int name_trn_id = 0;
  102.  
  103.   bzero((char *)&p,sizeof(p));
  104.  
  105.   if (!name_trn_id) name_trn_id = (time(NULL)%(unsigned)0x7FFF) + 
  106.     (getpid()%(unsigned)100);
  107.   name_trn_id = (name_trn_id+1) % (unsigned)0x7FFF;
  108.  
  109.   nmb->header.name_trn_id = name_trn_id;
  110.   nmb->header.opcode = 0;
  111.   nmb->header.response = False;
  112.   nmb->header.nm_flags.bcast = False;
  113.   nmb->header.nm_flags.recursion_available = False;
  114.   nmb->header.nm_flags.recursion_desired = False;
  115.   nmb->header.nm_flags.trunc = False;
  116.   nmb->header.nm_flags.authoritative = False;
  117.   nmb->header.rcode = 0;
  118.   nmb->header.qdcount = 1;
  119.   nmb->header.ancount = 0;
  120.   nmb->header.nscount = 0;
  121.   nmb->header.arcount = 0;
  122.  
  123.   make_nmb_name(&nmb->question.question_name,name,name_type,scope);
  124.  
  125.   nmb->question.question_type = 0x21;
  126.   nmb->question.question_class = 0x1;
  127.  
  128.   p.ip = to_ip;
  129.   p.port = NMB_PORT;
  130.   p.fd = fd;
  131.   p.timestamp = time(NULL);
  132.   p.packet_type = NMB_PACKET;
  133.  
  134.   GetTimeOfDay(&tval);
  135.  
  136.   if (!send_packet(&p)) 
  137.     return(False);
  138.  
  139.   retries--;
  140.  
  141.   while (1)
  142.     {
  143.       struct timeval tval2;
  144.       GetTimeOfDay(&tval2);
  145.       if (TvalDiff(&tval,&tval2) > retry_time) {
  146.     if (!retries) break;
  147.     if (!found && !send_packet(&p))
  148.       return False;
  149.     GetTimeOfDay(&tval);
  150.     retries--;
  151.       }
  152.  
  153.       if ((p2=receive_packet(fd,NMB_PACKET,90)))
  154.     {     
  155.       struct nmb_packet *nmb2 = &p2->packet.nmb;
  156.       debug_nmb_packet(p2);
  157.  
  158.       if (nmb->header.name_trn_id != nmb2->header.name_trn_id ||
  159.           !nmb2->header.response) {
  160.         /* its not for us - maybe deal with it later */
  161.         if (fn) 
  162.           fn(p2);
  163.         else
  164.           free_packet(p2);
  165.         continue;
  166.       }
  167.       
  168.       if (nmb2->header.opcode != 0 ||
  169.           nmb2->header.nm_flags.bcast ||
  170.           nmb2->header.rcode ||
  171.           !nmb2->header.ancount ||
  172.           nmb2->answers->rr_type != 0x21) {
  173.         /* XXXX what do we do with this? could be a redirect, but
  174.            we'll discard it for the moment */
  175.         free_packet(p2);
  176.         continue;
  177.       }
  178.  
  179.       _interpret_node_status(&nmb2->answers->rdata[0], master,rname);
  180.       free_packet(p2);
  181.       return(True);
  182.     }
  183.     }
  184.   
  185.  
  186.   DEBUG(0,("No status response (this is not unusual)\n"));
  187.  
  188.   return(False);
  189. }
  190.  
  191.  
  192. /****************************************************************************
  193.   do a netbios name query to find someones IP
  194.   returns an array of IP addresses or NULL if none
  195.   *count will be set to the number of addresses returned
  196.   ****************************************************************************/
  197. struct in_addr *name_query(int fd,char *name,int name_type, BOOL bcast,BOOL recurse,
  198.          struct in_addr to_ip, int *count, void (*fn)(struct packet_struct *))
  199. {
  200.   BOOL found=False;
  201.   int i, retries = 3;
  202.   int retry_time = bcast?250:2000;
  203.   struct timeval tval;
  204.   struct packet_struct p;
  205.   struct packet_struct *p2;
  206.   struct nmb_packet *nmb = &p.packet.nmb;
  207.   static int name_trn_id = 0;
  208.   struct in_addr *ip_list = NULL;
  209.  
  210.   bzero((char *)&p,sizeof(p));
  211.   (*count) = 0;
  212.  
  213.   if (!name_trn_id) name_trn_id = (time(NULL)%(unsigned)0x7FFF) + 
  214.     (getpid()%(unsigned)100);
  215.   name_trn_id = (name_trn_id+1) % (unsigned)0x7FFF;
  216.  
  217.   nmb->header.name_trn_id = name_trn_id;
  218.   nmb->header.opcode = 0;
  219.   nmb->header.response = False;
  220.   nmb->header.nm_flags.bcast = bcast;
  221.   nmb->header.nm_flags.recursion_available = False;
  222.   nmb->header.nm_flags.recursion_desired = recurse;
  223.   nmb->header.nm_flags.trunc = False;
  224.   nmb->header.nm_flags.authoritative = False;
  225.   nmb->header.rcode = 0;
  226.   nmb->header.qdcount = 1;
  227.   nmb->header.ancount = 0;
  228.   nmb->header.nscount = 0;
  229.   nmb->header.arcount = 0;
  230.  
  231.   make_nmb_name(&nmb->question.question_name,name,name_type,scope);
  232.  
  233.   nmb->question.question_type = 0x20;
  234.   nmb->question.question_class = 0x1;
  235.  
  236.   p.ip = to_ip;
  237.   p.port = NMB_PORT;
  238.   p.fd = fd;
  239.   p.timestamp = time(NULL);
  240.   p.packet_type = NMB_PACKET;
  241.  
  242.   GetTimeOfDay(&tval);
  243.  
  244.   if (!send_packet(&p)) 
  245.     return NULL;
  246.  
  247.   retries--;
  248.  
  249.   while (1)
  250.     {
  251.       struct timeval tval2;
  252.       GetTimeOfDay(&tval2);
  253.       if (TvalDiff(&tval,&tval2) > retry_time) {
  254.     if (!retries) break;
  255.     if (!found && !send_packet(&p))
  256.       return NULL;
  257.     GetTimeOfDay(&tval);
  258.     retries--;
  259.       }
  260.  
  261.       if ((p2=receive_packet(fd,NMB_PACKET,90)))
  262.     {     
  263.       struct nmb_packet *nmb2 = &p2->packet.nmb;
  264.       debug_nmb_packet(p2);
  265.  
  266.       if (nmb->header.name_trn_id != nmb2->header.name_trn_id ||
  267.           !nmb2->header.response) {
  268.         /* its not for us - maybe deal with it later 
  269.            (put it on the queue?) */
  270.         if (fn) 
  271.           fn(p2);
  272.         else
  273.           free_packet(p2);
  274.         continue;
  275.       }
  276.       
  277.       if (nmb2->header.opcode != 0 ||
  278.           nmb2->header.nm_flags.bcast ||
  279.           nmb2->header.rcode ||
  280.           !nmb2->header.ancount) {
  281.         /* XXXX what do we do with this? could be a redirect, but
  282.            we'll discard it for the moment */
  283.         free_packet(p2);
  284.         continue;
  285.       }
  286.  
  287.       ip_list = (struct in_addr *)Realloc(ip_list, sizeof(ip_list[0]) * 
  288.                           ((*count)+nmb2->answers->rdlength/6));
  289.       if (ip_list) {
  290.           DEBUG(fn?3:2,("Got a positive name query response from %s ( ",
  291.                 inet_ntoa(p2->ip)));
  292.           for (i=0;i<nmb2->answers->rdlength/6;i++) {
  293.               putip((char *)&ip_list[(*count)],&nmb2->answers->rdata[2+i*6]);
  294.               DEBUG(fn?3:2,("%s ",inet_ntoa(ip_list[(*count)])));
  295.               (*count)++;
  296.           }
  297.           DEBUG(fn?3:2,(")\n"));
  298.       }
  299.       found=True; retries=0;
  300.       free_packet(p2);
  301.       if (fn) break;
  302.     }
  303.     }
  304.  
  305.   return ip_list;
  306. }
  307.  
  308. /********************************************************
  309.  Start parsing the lmhosts file.
  310. *********************************************************/
  311.  
  312. FILE *startlmhosts(char *fname)
  313. {
  314.   FILE *fp = fopen(fname,"r");
  315.   if (!fp) {
  316.     DEBUG(2,("startlmhosts: Can't open lmhosts file %s. Error was %s\n",
  317.              fname, strerror(errno)));
  318.     return NULL;
  319.   }
  320.   return fp;
  321. }
  322.  
  323. /********************************************************
  324.  Parse the next line in the lmhosts file.
  325. *********************************************************/
  326.  
  327. BOOL getlmhostsent( FILE *fp, char *name, int *name_type, struct in_addr *ipaddr)
  328. {
  329.   pstring line;
  330.  
  331.   while(!feof(fp) && !ferror(fp)) {
  332.     pstring ip,flags,extra;
  333.     char *ptr;
  334.     int count = 0;
  335.  
  336.     *name_type = -1;
  337.  
  338.     if (!fgets_slash(line,sizeof(pstring),fp))
  339.       continue;
  340.  
  341.     if (*line == '#')
  342.       continue;
  343.  
  344.     pstrcpy(ip,"");
  345.     pstrcpy(name,"");
  346.     pstrcpy(flags,"");
  347.  
  348.     ptr = line;
  349.  
  350.     if (next_token(&ptr,ip   ,NULL))
  351.       ++count;
  352.     if (next_token(&ptr,name ,NULL))
  353.       ++count;
  354.     if (next_token(&ptr,flags,NULL))
  355.       ++count;
  356.     if (next_token(&ptr,extra,NULL))
  357.       ++count;
  358.  
  359.     if (count <= 0)
  360.       continue;
  361.  
  362.     if (count > 0 && count < 2)
  363.     {
  364.       DEBUG(0,("getlmhostsent: Ill formed hosts line [%s]\n",line));
  365.       continue;
  366.     }
  367.  
  368.     if (count >= 4)
  369.     {
  370.       DEBUG(0,("getlmhostsent: too many columns in lmhosts file (obsolete syntax)\n"));
  371.       continue;
  372.     }
  373.  
  374.     DEBUG(4, ("getlmhostsent: lmhost entry: %s %s %s\n", ip, name, flags));
  375.  
  376.     if (strchr(flags,'G') || strchr(flags,'S'))
  377.     {
  378.       DEBUG(0,("getlmhostsent: group flag in lmhosts ignored (obsolete)\n"));
  379.       continue;
  380.     }
  381.  
  382.     *ipaddr = *interpret_addr2(ip);
  383.  
  384.     /* Extra feature. If the name ends in '#XX', where XX is a hex number,
  385.        then only add that name type. */
  386.     if((ptr = strchr(name, '#')) != NULL)
  387.     {
  388.       char *endptr;
  389.  
  390.       ptr++;
  391.       *name_type = (int)strtol(ptr, &endptr,0);
  392.  
  393.       if(!*ptr || (endptr == ptr))
  394.       {
  395.         DEBUG(0,("getlmhostsent: invalid name %s containing '#'.\n", name));
  396.         continue;
  397.       }
  398.  
  399.       *(--ptr) = '\0'; /* Truncate at the '#' */
  400.     }
  401.  
  402.     return True;
  403.   }
  404.  
  405.   return False;
  406. }
  407.  
  408. /********************************************************
  409.  Finish parsing the lmhosts file.
  410. *********************************************************/
  411.  
  412. void endlmhosts(FILE *fp)
  413. {
  414.   fclose(fp);
  415. }
  416.  
  417. /********************************************************
  418.  Resolve a name into an IP address. Use this function if
  419.  the string is either an IP address, DNS or host name
  420.  or NetBIOS name. This uses the name switch in the
  421.  smb.conf to determine the order of name resolution.
  422. *********************************************************/
  423.  
  424. BOOL resolve_name(char *name, struct in_addr *return_ip)
  425. {
  426.   int i;
  427.   BOOL pure_address = True;
  428.   pstring name_resolve_list;
  429.   fstring tok;
  430.   char *ptr;
  431.  
  432.   if (strcmp(name,"0.0.0.0") == 0) {
  433.     return_ip->s_addr = 0;
  434.     return True;
  435.   }
  436.   if (strcmp(name,"255.255.255.255") == 0) {
  437.     return_ip->s_addr = 0xFFFFFFFF;
  438.     return True;
  439.   }
  440.    
  441.   for (i=0; pure_address && name[i]; i++)
  442.     if (!(isdigit(name[i]) || name[i] == '.'))
  443.       pure_address = False;
  444.    
  445.   /* if it's in the form of an IP address then get the lib to interpret it */
  446.   if (pure_address) {
  447.     return_ip->s_addr = inet_addr(name);
  448.     return True;
  449.   }
  450.  
  451.   pstrcpy(name_resolve_list, lp_name_resolve_order());
  452.   ptr = name_resolve_list;
  453.   if (!ptr || !*ptr) ptr = "host";
  454.  
  455.   while (next_token(&ptr, tok, LIST_SEP)) {
  456.     if(strequal(tok, "host") || strequal(tok, "hosts")) {
  457.  
  458.       /*
  459.        * "host" means do a localhost, or dns lookup.
  460.        */
  461.  
  462.       struct hostent *hp;
  463.  
  464.       DEBUG(3,("resolve_name: Attempting host lookup for name %s\n", name));
  465.  
  466.       if (((hp = Get_Hostbyname(name)) != NULL) && (hp->h_addr != NULL)) {
  467.         putip((char *)return_ip,(char *)hp->h_addr);
  468.         return True;
  469.       }
  470.  
  471.     } else if(strequal( tok, "lmhosts")) {
  472.  
  473.       /*
  474.        * "lmhosts" means parse the local lmhosts file.
  475.        */
  476.  
  477.       FILE *fp;
  478.       pstring lmhost_name;
  479.       int name_type;
  480.  
  481.       DEBUG(3,("resolve_name: Attempting lmhosts lookup for name %s\n", name));
  482.  
  483.       fp = startlmhosts( LMHOSTSFILE );
  484.       if(fp) {
  485.         while( getlmhostsent(fp, lmhost_name, &name_type, return_ip ) ) {
  486.           if( strequal(name, lmhost_name )) {
  487.             endlmhosts(fp);
  488.             return True; 
  489.           }
  490.         }
  491.         endlmhosts(fp);
  492.       }
  493.  
  494.     } else if(strequal( tok, "wins")) {
  495.  
  496.       int sock;
  497.  
  498.       /*
  499.        * "wins" means do a unicast lookup to the WINS server.
  500.        * Ignore if there is no WINS server specified or if the
  501.        * WINS server is one of our interfaces (if we're being
  502.        * called from within nmbd - we can't do this call as we
  503.        * would then block).
  504.        */
  505.  
  506.       DEBUG(3,("resolve_name: Attempting wins lookup for name %s<0x20>\n", name));
  507.  
  508.       if(*lp_wins_server()) {
  509.         struct in_addr wins_ip = *interpret_addr2(lp_wins_server());
  510.         BOOL wins_ismyip = ismyip(wins_ip);
  511.  
  512.         if((wins_ismyip && !global_in_nmbd) || !wins_ismyip) {
  513.           sock = open_socket_in( SOCK_DGRAM, 0, 3,
  514.                                interpret_addr(lp_socket_address()) );
  515.  
  516.           if (sock != -1) {
  517.             struct in_addr *iplist = NULL;
  518.             int count;
  519.             iplist = name_query(sock, name, 0x20, False, True, wins_ip, &count, NULL);
  520.             if(iplist != NULL) {
  521.               *return_ip = iplist[0];
  522.               free((char *)iplist);
  523.               close(sock);
  524.               return True;
  525.             }
  526.             close(sock);
  527.           }
  528.         }
  529.       } else {
  530.         DEBUG(3,("resolve_name: WINS server resolution selected and no WINS server present.\n"));
  531.       }
  532.     } else if(strequal( tok, "bcast")) {
  533.  
  534.       int sock;
  535.  
  536.       /*
  537.        * "bcast" means do a broadcast lookup on all the local interfaces.
  538.        */
  539.  
  540.       DEBUG(3,("resolve_name: Attempting broadcast lookup for name %s<0x20>\n", name));
  541.  
  542.       sock = open_socket_in( SOCK_DGRAM, 0, 3,
  543.                              interpret_addr(lp_socket_address()) );
  544.  
  545.       if (sock != -1) {
  546.         struct in_addr *iplist = NULL;
  547.         int count;
  548.         int num_interfaces = iface_count();
  549.         set_socket_options(sock,"SO_BROADCAST");
  550.         /*
  551.          * Lookup the name on all the interfaces, return on
  552.          * the first successful match.
  553.          */
  554.         for( i = 0; i < num_interfaces; i++) {
  555.           struct in_addr sendto_ip = *iface_bcast(*iface_n_ip(i));
  556.           iplist = name_query(sock, name, 0x20, True, False, sendto_ip, &count, NULL);
  557.           if(iplist != NULL) {
  558.             *return_ip = iplist[0];
  559.             free((char *)iplist);
  560.             close(sock);
  561.             return True;
  562.           }
  563.         }
  564.         close(sock);
  565.       }
  566.  
  567.     } else {
  568.       DEBUG(0,("resolve_name: unknown name switch type %s\n", tok));
  569.     }
  570.   }
  571.  
  572.   return False;
  573. }
  574.